Open Multithreaded Transactions: A Transaction Model for Concurrent Object-Oriented Programming

Modern programming languages provide features that allow a programmer to express concurrency in an application by using active objects, i.e. objects with their own thread of control, and distribution. Concurrent systems can be classified into cooperative systems, where individual components collaborate, share results and work for a common goal, and competitive systems, where the individual components are not aware of each other and compete for shared resources. Programming languages address collaboration and competition by providing means for communication and synchronization among active objects. The realization of complex object-oriented systems often needs sophisticated and elaborate concurrency features which may go beyond the traditional concurrency control associated with separate method calls. A transaction groups together a sequence of actions, and can therefore encapsulate complex behavior and embrace groups of objects and method calls. Transactions structure the dynamic system execution as opposed to the static structuring based on objects. Because of the ACID properties, transactions are able to hide the effects of concurrency and at the same time act as firewalls for errors, making them appropriate building blocks for structuring reliable distributed systems. This thesis investigates how transactions can be integrated with concurrent object-oriented programming, and in particular, how transactions can be made available to an application programmer at the programming language level. In the first part of the thesis, existing transaction models are reviewed and their suitability for concurrent programming languages is discussed. The analysis of existing models of multithreaded transactions shows that they either give too much freedom to threads and do not control their participation in transactions, or unnecessarily restrict the computational model by assuming that only one thread can enter a transaction. Hence, a significant part of this thesis is devoted to the establishment of a new transaction model named Open Multithreaded Transactions, providing features for controlling and structuring not only accesses to objects, as usual in transaction systems, but also threads taking part in transactions. The model allows several threads to enter the same transaction in order to perform a joint activity. It provides a flexible way of manipulating threads executing inside a transaction by allowing them to be forked and terminated, but it restricts their behavior in order to guarantee correctness of transaction nesting and isolation among transactions. The open multithreaded transaction model incorporates disciplined exception handling adapted to nested transactions. It allows individual threads to perform forward error recovery by handling an abnormal situation locally, and promotes a defensive approach for developing transactional objects, so that errors are detected early and dealt with inside the transaction. If local handling fails, the transaction support applies backward error recovery and reverses the system to its “initial” state.